package Clases;

import JDBC.DatabaseConnection;
import java.sql.*;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;
import javax.swing.JOptionPane;

public class Consulta {

    public static User userInSession = null;

    public static void showErrorMessage(Object message) {
        JOptionPane.showMessageDialog(null, message, "ERROR", JOptionPane.ERROR_MESSAGE);
        //System.out.println(message);
    }

    public static void showMessage(Object message) {
        JOptionPane.showMessageDialog(null, message, "INFORMATION", JOptionPane.INFORMATION_MESSAGE);
        //System.out.println(message);
    }

    public static void session(String username, String password) {

        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            User user = null;
            CONSULTA = "SELECT * FROM USUARIO "
                    + "WHERE USERNAME=? AND PASSWORD=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, username);
            preparedStatement.setString(2, password);
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                String cedula = resultSet.getString("CEDULA");
                String codigodependencia = resultSet.getString("CODIGO_DEPENDENCIA");
                String pass = resultSet.getString("PASSWORD");
                String usern = resultSet.getString("USERNAME");
                String rol = resultSet.getString("ROL");
                Dependencia dependencia = getDependencia(connection, codigodependencia);
                if (cedula != null && codigodependencia != null && pass != null && usern != null && dependencia != null) {
                    user = new User(cedula, usern, pass, dependencia, rol);
                }
                userInSession = user;
            }
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {

            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
    }

    public static Dependencia getDependencias(Connection connection, String departamento) {

        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            Dependencia dependencia = null;
            CONSULTA = "SELECT * FROM DEPENDENCIA "
                    + "WHERE DEPARTAMENTO=?";
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, departamento);
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                String codigoTmp = resultSet.getString("CODIGO_DEPENDENCIA");
                String dep = resultSet.getString("DEPARTAMENTO");
                if (codigoTmp != null && dep != null) {
                    dependencia = new Dependencia(codigoTmp, dep);
                }
            }
            return dependencia;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
        return null;
    }

    public static void agregarProducto(String descripcion) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "INSERT INTO PRODUCTO (CODIGO_PRODUCTO,DESCRIPCION) VALUES (INCREMENTO_CODIGO_PRODUCTO.NextVal,?)";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, descripcion);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al insertar El producto");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void agregarProveedor(String nit, String direccion, String ciudad,
            String estado, String pais, int telefono, String nombre) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "INSERT INTO PROVEEDOR "
                    + "(CODIGO_PROVEEDOR,NIT,DIRECCION,CIUDAD,ESTADO,PAIS,TELEFONO,NOMBRE) "
                    + "VALUES (INCREMENTO_CODIGO_PROVEEDOR.NextVal,?,?,?,?,?,?,?)";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, nit);
            preparedStatement.setString(2, direccion);
            preparedStatement.setString(3, ciudad);
            preparedStatement.setString(4, estado);
            preparedStatement.setString(5, pais);
            preparedStatement.setInt(6, telefono);
            preparedStatement.setString(7, nombre);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al insertar El proveedor");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void agregarDependencia(String departamento) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "INSERT INTO DEPENDENCIA (CODIGO_DEPENDENCIA,DEPARTAMENTO) VALUES (INCREMENTO_CODIGO_DEPENDENCIA.NextVal,?)";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, departamento);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al insertar la Dependencia");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void agregarBancoDeDatos(String codigoProducto, String codigoProveedor, Double precioUnidad) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "INSERT INTO BANCO_DATOS (CODIGO_BANCO,CODIGO_PRODUCTO, CODIGO_PROVEEDOR, PRECIO_UNIDAD) VALUES (INCREMENTO_CODIGO_BANCO.NextVal,?,?,?)";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoProducto);
            preparedStatement.setString(2, codigoProveedor);
            preparedStatement.setDouble(3, precioUnidad);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al insertar los Datos");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void agregarOrden(String fecha, String codigoProveedor) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "INSERT INTO ORDEN (CODIGO_ORDEN,FECHA, CODIGO_PROVEEDOR) VALUES (INCREMENTO_CODIGO_ORDEN.NextVal,?,?)";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, fecha);
            preparedStatement.setString(2, codigoProveedor);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al insertar la Orden de compra");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void agregarOrdenDetalle(String codigoOrden, String codigoProducto, int cantidad) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "INSERT INTO DETALLE_ORDEN (CODIGO_DETALLE,CODIGO_ORDEN, CODIGO_PRODUCTO,CANTIDAD) VALUES (INCREMENTO_CODIGO_DETALLE_O.NextVal,?,?,?)";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoOrden);
            preparedStatement.setString(2, codigoProducto);
            preparedStatement.setInt(3, cantidad);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al insertar el detalle de  la orden de compra");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void agregarEntrada(String codigoOrden, String fecha) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {

            CONSULTA = "INSERT INTO ENTRADA (CODIGO_ENTRADA,CODIGO_ORDEN, FECHA) VALUES (INCREMENTO_CODIGO_ENTRADA.NextVal,?,?)";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoOrden);
            preparedStatement.setString(2, fecha);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al insertar la entrada");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void agregarDetalleEntrada(String codigoEntrada, String codigoProveedor, String codigoProducto, int cantidad) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {

            CONSULTA = "INSERT INTO DETALLE_ENTRADA (CODIGO_DETALLE,CODIGO_ENTRADA,CODIGO_PROVEEDOR,CODIGO_PRODUCTO,CANTIDAD) VALUES (INCREMENTO_CODIGO_DETALLE_E.NextVal,?,?,?,?)";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoEntrada);
            preparedStatement.setString(2, codigoProveedor);
            preparedStatement.setString(3, codigoProducto);
            preparedStatement.setInt(4, cantidad);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al insertar el detalle de la entrada entrada");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void agregarSolicitud(int codigoDependencia, String fecha) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "INSERT INTO SOLICITUD (CODIGO_SOLICITUD,CODIGO_DEPENDENCIA, FECHA) VALUES (INCREMENTO_CODIGO_SOLICITUD.NextVal,?,?)";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setInt(1, codigoDependencia);
            preparedStatement.setString(2, fecha);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al insertar la Solicitud");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void agregarDetalleSolicitud(String codigoSolicitud, String codigoProducto, int cantidad) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "INSERT INTO DETALLE_SOLICITUD "
                    + "(CODIGO_DETALLE,CODIGO_SOLICITUD,CODIGO_PRODUCTO,CANTIDAD_APROBADA) "
                    + "VALUES (INCREMENTO_CODIGO_DETALLE_S.NextVal,?,?,?)";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoSolicitud);
            preparedStatement.setString(2, codigoProducto);
            preparedStatement.setInt(3, cantidad);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al insertar el detalle de la Solicitud");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static List<Dependencia> getDependencias() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            List<Dependencia> dependencias = null;
            CONSULTA = "SELECT * FROM DEPENDENCIA "
                    + "ORDER BY CODIGO_DEPENDENCIA ";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                String codigo = resultSet.getString("CODIGO_DEPENDENCIA");
                String dep = resultSet.getString("DEPARTAMENTO");
                Dependencia d = new Dependencia(codigo, dep);

                if (dependencias == null) {
                    dependencias = new ArrayList<Dependencia>();
                }
                dependencias.add(d);
            }
            return dependencias;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {

            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static Dependencia getDependencias(String codigoDependencia) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            Dependencia d = null;
            CONSULTA = "SELECT * FROM DEPENDENCIA "
                    + "WHERE CODIGO_DEPENDENCIA=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoDependencia);
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                String codigo = resultSet.getString("CODIGO_DEPENDENCIA");
                String dep = resultSet.getString("DEPARTAMENTO");
                d = new Dependencia(codigo, dep);
            }
            return d;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {

            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static List<Proveedor> getProveedores() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            List<Proveedor> proveedores = null;
            CONSULTA = "SELECT * FROM PROVEEDOR "
                    + "ORDER BY CODIGO_PROVEEDOR";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                String codigoProveedor = resultSet.getString("CODIGO_PROVEEDOR");
                String nit = resultSet.getString("NIT");
                String direccion = resultSet.getString("DIRECCION");
                String ciudad = resultSet.getString("CIUDAD");
                String estado = resultSet.getString("ESTADO");
                String pais = resultSet.getString("PAIS");
                String telefono = resultSet.getString("TELEFONO");
                String nombre = resultSet.getString("NOMBRE");
                Proveedor proveedor = new Proveedor(Long.valueOf(codigoProveedor), nit, nombre, direccion, ciudad, estado, pais, telefono);

                if (proveedores == null) {
                    proveedores = new ArrayList<Proveedor>();
                }
                proveedores.add(proveedor);
            }
            return proveedores;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {

            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static Proveedor getProveedor(String codigo) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            Proveedor proveedor = null;
            CONSULTA = "SELECT * FROM PROVEEDOR "
                    + "WHERE CODIGO_PROVEEDOR=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigo);
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                String codigoProveedor = resultSet.getString("CODIGO_PROVEEDOR");
                String nit = resultSet.getString("NIT");
                String direccion = resultSet.getString("DIRECCION");
                String ciudad = resultSet.getString("CIUDAD");
                String estado = resultSet.getString("ESTADO");
                String pais = resultSet.getString("PAIS");
                String telefono = resultSet.getString("TELEFONO");
                String nombre = resultSet.getString("NOMBRE");
                proveedor = new Proveedor(Long.valueOf(codigoProveedor), nit, nombre, direccion, ciudad, estado, pais, telefono);
            }
            return proveedor;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {

            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static Proveedor getProveedor(Connection connection, String codigo) {
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            Proveedor proveedor = null;
            CONSULTA = "SELECT * FROM PROVEEDOR "
                    + "WHERE CODIGO_PROVEEDOR=?";
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigo);
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                String codigoProveedor = resultSet.getString("CODIGO_PROVEEDOR");
                String nit = resultSet.getString("NIT");
                String direccion = resultSet.getString("DIRECCION");
                String ciudad = resultSet.getString("CIUDAD");
                String estado = resultSet.getString("ESTADO");
                String pais = resultSet.getString("PAIS");
                String telefono = resultSet.getString("TELEFONO");
                String nombre = resultSet.getString("NOMBRE");
                proveedor = new Proveedor(Long.valueOf(codigoProveedor), nit, nombre, direccion, ciudad, estado, pais, telefono);
            }
            return proveedor;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
        return null;
    }

    public static List<Solicitud> getSolicitud() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            List<Solicitud> solicitudes = null;
            CONSULTA = "SELECT * FROM SOLICITUD "
                    + "ORDER BY CODIGO_SOLICITUD";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                String codigoSolicitud = resultSet.getString("CODIGO_SOLICITUD");
                String codigoDependencia = resultSet.getString("CODIGO_DEPENDENCIA");
                String fecha = resultSet.getString("FECHA");
                Dependencia dependencia = getDependencia(connection, codigoDependencia);
                List<SolicitudDetalle> detalles = getDetalleSolicitud(connection, codigoSolicitud);
                Solicitud solicitud = new Solicitud(codigoSolicitud, dependencia, fecha, detalles);

                if (solicitudes == null) {
                    solicitudes = new ArrayList<Solicitud>();
                }
                solicitudes.add(solicitud);
            }
            return solicitudes;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static Solicitud getSolicitud(String codigo) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            Solicitud solicitud = null;
            CONSULTA = "SELECT * FROM SOLICITUD "
                    + "WHERE CODIGO_SOLICITUD =?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigo);
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                String codigoSolicitud = resultSet.getString("CODIGO_SOLICITUD");
                String codigoDependencia = resultSet.getString("CODIGO_DEPENDENCIA");
                String fecha = resultSet.getString("FECHA");
                Dependencia dependencia = getDependencia(connection, codigoDependencia);
                List<SolicitudDetalle> detalles = getDetalleSolicitud(connection, codigoSolicitud);
                solicitud = new Solicitud(codigoSolicitud, dependencia, fecha, detalles);
            }
            return solicitud;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static List<SolicitudDetalle> getDetalleSolicitud(Connection connection, String codigoSolicitud) {
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            List<SolicitudDetalle> solicitudes = null;
            CONSULTA = "SELECT * FROM DETALLE_SOLICITUD "
                    + "WHERE CODIGO_SOLICITUD=? "
                    + "ORDER BY CODIGO_DETALLE";
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoSolicitud);
            resultSet = preparedStatement.executeQuery();
            int i = resultSet.getRow();
            while (resultSet.next()) {
                String codigoDetalle = resultSet.getString("CODIGO_DETALLE");
                String codigoSolicitudTmp = resultSet.getString("CODIGO_SOLICITUD");
                String codigoProducto = resultSet.getString("CODIGO_PRODUCTO");
                String cantidadAprobada = resultSet.getString("CANTIDAD_APROBADA");
                Producto producto = getProductoFromCodigo(connection, codigoProducto);
                SolicitudDetalle solicitud = new SolicitudDetalle(codigoDetalle, codigoSolicitudTmp, producto, Integer.valueOf(cantidadAprobada));

                if (solicitudes == null) {
                    solicitudes = new ArrayList<SolicitudDetalle>();
                }
                solicitudes.add(solicitud);
            }
            return solicitudes;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
        return null;
    }

    public static List<Entrada> listarEntrada() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            List<Entrada> entradas = null;
            CONSULTA = "SELECT * FROM ENTRADA "
                    + "ORDER BY CODIGO_ENTRADA";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                String codigoEntrada = resultSet.getString("CODIGO_ENTRADA");
                String codigoOrden = resultSet.getString("CODIGO_ORDEN");
                String fecha = resultSet.getString("FECHA");
                List<EntradaDetalle> detalles = getDetalleEntrada(connection, codigoEntrada);
                Entrada entrada = new Entrada(codigoEntrada, codigoOrden, fecha, detalles);

                if (entradas == null) {
                    entradas = new ArrayList<Entrada>();
                }
                entradas.add(entrada);
            }
            return entradas;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static List<EntradaDetalle> getDetalleEntrada(Connection connection, String codigoEntrada) {
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            List<EntradaDetalle> entradas = null;
            CONSULTA = "SELECT * FROM DETALLE_ENTRADA "
                    + "WHERE CODIGO_ENTRADA=? "
                    + "ORDER BY CODIGO_DETALLE";
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoEntrada);
            resultSet = preparedStatement.executeQuery();
            int i = resultSet.getRow();
            while (resultSet.next()) {
                String codigoDetalle = resultSet.getString("CODIGO_DETALLE");
                String codigoProveedor = resultSet.getString("CODIGO_PROVEEDOR");
                String codigoProducto = resultSet.getString("CODIGO_PRODUCTO");
                String cantidad = resultSet.getString("CANTIDAD");
                Producto producto = getProductoFromCodigo(connection, codigoProducto);
                Proveedor proveedor = getProveedor(connection, codigoProveedor);
                EntradaDetalle entrada = new EntradaDetalle(codigoDetalle, codigoEntrada, proveedor, producto, Integer.valueOf(cantidad));

                if (entradas == null) {
                    entradas = new ArrayList<EntradaDetalle>();
                }
                entradas.add(entrada);
            }
            return entradas;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
        return null;
    }

    public static Producto getProductoFromCodigo(Connection connection, String codigoProducto) {
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            Producto producto = null;
            CONSULTA = "SELECT * FROM PRODUCTO "
                    + "WHERE CODIGO_PRODUCTO = ?";
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoProducto);
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                String codigoProductoTmp = resultSet.getString("CODIGO_PRODUCTO");
                String descripcion = resultSet.getString("DESCRIPCION");
                producto = new Producto(codigoProductoTmp, descripcion);
            }
            return producto;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
        return null;
    }

    public static Dependencia getDependencia(Connection connection, String codigoDependencia) {
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            Dependencia dependencia = null;
            CONSULTA = "SELECT * FROM DEPENDENCIA "
                    + "WHERE CODIGO_DEPENDENCIA=?";
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoDependencia);
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                String codigoDependenciaTmp = resultSet.getString("CODIGO_DEPENDENCIA");
                String departamento = resultSet.getString("DEPARTAMENTO");
                dependencia = new Dependencia(codigoDependenciaTmp, departamento);
            }
            return dependencia;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
        return null;
    }

    public static Date getDate(String fecha) {
        try {
            DateFormat formatter;
            Date date;
            formatter = new SimpleDateFormat("MM/dd/yyyy");
            date = (Date) formatter.parse(fecha);
            return date;
        } catch (ParseException e) {
            showErrorMessage(e);
        }
        return null;
    }

    public static List<Proveedor> getProveedores(String descripcionProducto) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            List<Proveedor> proveedores = null;
            CONSULTA = "SELECT P.CODIGO_PROVEEDOR,P.NIT,P.DIRECCION,P.CIUDAD,P.ESTADO,"
                    + "P.PAIS,P.TELEFONO,P.NOMBRE FROM PROVEEDOR P, BANCO_DATOS B "
                    + "WHERE B.CODIGO_PRODUCTO =(SELECT CODIGO_PRODUCTO FROM PRODUCTO WHERE DESCRIPCION =?) "
                    + " AND B.CODIGO_PROVEEDOR = P.CODIGO_PROVEEDOR "
                    + "ORDER BY P.CODIGO_PROVEEDOR";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, descripcionProducto);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                String codigoProveedor = resultSet.getString("CODIGO_PROVEEDOR");
                String nit = resultSet.getString("NIT");
                String direccion = resultSet.getString("DIRECCION");
                String ciudad = resultSet.getString("CIUDAD");
                String estado = resultSet.getString("ESTADO");
                String pais = resultSet.getString("PAIS");
                String telefono = resultSet.getString("TELEFONO");
                String nombre = resultSet.getString("NOMBRE");
                Proveedor proveedor = new Proveedor(Long.valueOf(codigoProveedor), nit, direccion, ciudad, estado, pais, telefono, nombre);
                if (proveedores == null) {
                    proveedores = new ArrayList<Proveedor>();
                }
                proveedores.add(proveedor);
            }
            return proveedores;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static String getCodigoProveedor(String nombreProveedor) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            String codigoProveedor = null;
            CONSULTA = "SELECT CODIGO_PROVEEDOR FROM PROVEEDOR "
                    + "WHERE NOMBRE = ?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, nombreProveedor);
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                codigoProveedor = resultSet.getString("CODIGO_PROVEEDOR");
            }
            return codigoProveedor;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static String getCodigoProducto(String nombreProducto) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            String codigoProducto = null;
            CONSULTA = "SELECT CODIGO_PRODUCTO FROM PRODUCTO "
                    + "WHERE DESCRIPCION = ?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, nombreProducto);
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                codigoProducto = resultSet.getString("CODIGO_PRODUCTO");
            }
            return codigoProducto;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static List<Producto> getProductos() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            List<Producto> productos = null;
            CONSULTA = "SELECT * FROM PRODUCTO "
                    + "ORDER BY CODIGO_PRODUCTO";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                String codigoProducto = resultSet.getString("CODIGO_PRODUCTO");
                String descripcion = resultSet.getString("DESCRIPCION");
                Producto producto = new Producto(codigoProducto, descripcion);
                if (productos == null) {
                    productos = new ArrayList<Producto>();
                }
                productos.add(producto);
            }
            return productos;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static List<Producto> getProductos(String nombreProveedor) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            List<Producto> productos = null;
            CONSULTA = "SELECT P.CODIGO_PRODUCTO,P.DESCRIPCION "
                    + "FROM PRODUCTO P, BANCO_DATOS B "
                    + "WHERE B.CODIGO_PROVEEDOR =(SELECT CODIGO_PROVEEDOR FROM PROVEEDOR WHERE NOMBRE =?) "
                    + "AND B.CODIGO_PRODUCTO = P.CODIGO_PRODUCTO "
                    + "ORDER BY P.CODIGO_PRODUCTO";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, nombreProveedor);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                String codigoProducto = resultSet.getString("CODIGO_PRODUCTO");
                String descripcion = resultSet.getString("DESCRIPCION");
                Producto producto = new Producto(codigoProducto, descripcion);
                if (productos == null) {
                    productos = new ArrayList<Producto>();
                }
                productos.add(producto);
            }
            return productos;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static List<Orden> getOrden() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            List<Orden> ordenes = null;
            CONSULTA = "SELECT * FROM ORDEN "
                    + "ORDER BY CODIGO_ORDEN";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                String codigoOrden = resultSet.getString("CODIGO_ORDEN");
                String codigoProveedor = resultSet.getString("CODIGO_PROVEEDOR");
                String fecha = resultSet.getString("FECHA");
                List<OrdenDetalle> detalles = getDetalleOrden(connection, codigoOrden);
                Orden orden = new Orden(codigoOrden, codigoProveedor, fecha, detalles);

                if (ordenes == null) {
                    ordenes = new ArrayList<Orden>();
                }
                ordenes.add(orden);
            }
            return ordenes;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static List<OrdenDetalle> getDetalleOrden(Connection connection, String codigoOrden) {
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            List<OrdenDetalle> detalles = null;
            CONSULTA = "SELECT * FROM DETALLE_ORDEN "
                    + "WHERE CODIGO_ORDEN=? "
                    + "ORDER BY CODIGO_DETALLE";
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoOrden);
            resultSet = preparedStatement.executeQuery();
            int i = resultSet.getRow();
            while (resultSet.next()) {
                String codigoDetalle = resultSet.getString("CODIGO_DETALLE");
                String codigoOrdenTmp = resultSet.getString("CODIGO_ORDEN");
                String codigoProducto = resultSet.getString("CODIGO_PRODUCTO");
                String cantidad = resultSet.getString("CANTIDAD");
                Producto producto = getProductoFromCodigo(connection, codigoProducto);
                OrdenDetalle orden = new OrdenDetalle(codigoDetalle, codigoOrdenTmp, producto, Integer.valueOf(cantidad));

                if (detalles == null) {
                    detalles = new ArrayList<OrdenDetalle>();
                }
                detalles.add(orden);
            }
            return detalles;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
        return null;
    }

    public static Orden getOrden(String codigo) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            Orden orden = null;
            CONSULTA = "SELECT * FROM ORDEN "
                    + "WHERE CODIGO_ORDEN=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigo);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                String codigoOrden = resultSet.getString("CODIGO_ORDEN");
                String codigoProveedor = resultSet.getString("CODIGO_PROVEEDOR");
                String fecha = resultSet.getString("FECHA");
                List<OrdenDetalle> detalles = getDetalleOrden(connection, codigoOrden);
                orden = new Orden(codigoOrden, codigoProveedor, fecha, detalles);

            }
            return orden;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static List<Banco> getDatosBanco() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            CONSULTA = "SELECT * FROM BANCO_DATOS ";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            resultSet = preparedStatement.executeQuery();
            List<Banco> datos = null;
            while (resultSet.next()) {
                String codigoBanco = resultSet.getString("CODIGO_BANCO");
                String codigoProducto = resultSet.getString("CODIGO_PRODUCTO");
                String codigoProveedor = resultSet.getString("CODIGO_PROVEEDOR");
                String precioUnidad = resultSet.getString("PRECIO_UNIDAD");
                Proveedor proveedor = getProveedor(connection, codigoProveedor);
                Producto producto = getProductoFromCodigo(connection, codigoProducto);
                Banco banco = new Banco(codigoBanco, producto, proveedor, Double.valueOf(precioUnidad));
                if (datos == null) {
                    datos = new ArrayList<Banco>();
                }
                datos.add(banco);
            }
            return datos;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static Banco getBanco(String codigoProducto, String codigoProveedor) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            CONSULTA = "SELECT * FROM BANCO_DATOS "
                    + "WHERE CODIGO_PRODUCTO =? AND CODIGO_PROVEEDOR = ?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoProducto);
            preparedStatement.setString(2, codigoProveedor);
            resultSet = preparedStatement.executeQuery();
            Banco banco = null;
            if (resultSet.next()) {
                String codigoBanco = resultSet.getString("CODIGO_BANCO");
                String precioUnidad = resultSet.getString("PRECIO_UNIDAD");
                Proveedor proveedor = getProveedor(connection, codigoProveedor);
                Producto producto = getProductoFromCodigo(connection, codigoProducto);
                banco = new Banco(codigoBanco, producto, proveedor, Double.valueOf(precioUnidad));
            }
            return banco;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static void registrarUsuario(String cedula, String username, String Password, String departamento, String tipoRol) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;

        try {
            CONSULTA = "INSERT INTO USUARIO (CEDULA,USERNAME,PASSWORD,CODIGO_DEPENDENCIA,ROL) "
                    + "VALUES (?,?,?,?,?)";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            Dependencia dependencia = getDependencias(connection, departamento);
            if (dependencia == null) {
                showErrorMessage("El departamento no existe.");
            } else {
                preparedStatement.setString(1, cedula);
                preparedStatement.setString(2, username);
                preparedStatement.setString(3, Password);
                preparedStatement.setString(4, dependencia.getCodigo());
                preparedStatement.setString(5, tipoRol);

                /*
                 */
                int filasInsertadas = preparedStatement.executeUpdate();
                if (filasInsertadas != 1) {
                    throw new SQLException("Problemas al insertar El producto");
                }
                connection.commit();
                // Se destruyen los objetos
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }

            }
        } catch (SQLException ex) {
            showErrorMessage(" El usuario no se pudo crear. \n Error : " + ex);
        }

    }

    public static List<User> listarUsuario() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            CONSULTA = "SELECT * FROM USUARIO "
                    + "ORDER BY CEDULA";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            resultSet = preparedStatement.executeQuery();
            List<User> users = null;
            while (resultSet.next()) {
                String cedula = resultSet.getString("CEDULA");
                String username = resultSet.getString("USERNAME");
                String password = resultSet.getString("PASSWORD");
                String codigoDependencia = resultSet.getString("CODIGO_DEPENDENCIA");
                String rol = resultSet.getString("ROL");
                Dependencia dependencia = getDependencias(codigoDependencia);
                User user = new User(cedula, username, password, dependencia, rol);
                if (users == null) {
                    users = new LinkedList<User>();
                }
                users.add(user);
            }
            return users;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static User getUsuario(String cedula) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String CONSULTA = null;
        try {
            CONSULTA = "SELECT * FROM USUARIO "
                    + "WHERE CEDULA=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, cedula);
            resultSet = preparedStatement.executeQuery();
            User user = null;
            if (resultSet.next()) {
                String username = resultSet.getString("USERNAME");
                String password = resultSet.getString("PASSWORD");
                String codigoDependencia = resultSet.getString("CODIGO_DEPENDENCIA");
                String rol = resultSet.getString("ROL");
                Dependencia dependencia = getDependencias(codigoDependencia);
                user = new User(cedula, username, password, dependencia, rol);

            }
            return user;
        } catch (SQLException ex) {
            showErrorMessage(ex);
        } finally {
            try {
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException ex) {
                showErrorMessage(ex);
            }
        }
        return null;
    }

    public static void cambiarContraseña(String cedula, String contraseña) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "UPDATE USUARIO SET PASSWORD=?"
                    + "WHERE CEDULA=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, contraseña);
            preparedStatement.setString(2, cedula);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al cambiar contraseña");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }

        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void editarDependencia(String codigoDepartamento, String departamento) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "UPDATE DEPENDENCIA SET DEPARTAMENTO=? "
                    + "WHERE CODIGO_DEPENDENCIA=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, departamento);
            preparedStatement.setString(2, codigoDepartamento);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al editar la dependencia");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }

        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void editarProducto(String codigoProducto, String codigoProveedor, String precio, String Codigo) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "UPDATE BANCO_DATOS SET CODIGO_PRODUCTO=?,CODIGO_PROVEEDOR=?,PRECIO_UNIDAD=? "
                    + "WHERE CODIGO_BANCO=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoProducto);
            preparedStatement.setString(2, codigoProveedor);
            preparedStatement.setString(3, precio);
            preparedStatement.setString(4, Codigo);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al editar la el banco de datos");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }

        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void editarNombreProducto(String codigoProducto, String nombre) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "UPDATE PRODUCTO SET DESCRIPCION=? "
                    + "WHERE CODIGO_PRODUCTO=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, nombre);
            preparedStatement.setString(2, codigoProducto);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al editar el producto");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }

        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void editarProveedor(String nit, String direccion, String ciudad,
            String estado, String pais, int telefono, String nombre, String codigo) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "UPDATE proveedor SET NIT=?, DIRECCION=?, CIUDAD=?, ESTADO=?, PAIS=?, TELEFONO=?, NOMBRE=? "
                    + "WHERE CODIGO_PROVEEDOR=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, nit);
            preparedStatement.setString(2, direccion);
            preparedStatement.setString(3, ciudad);
            preparedStatement.setString(4, estado);
            preparedStatement.setString(5, pais);
            preparedStatement.setInt(6, telefono);
            preparedStatement.setString(7, nombre);
            preparedStatement.setString(8, codigo);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al editar el producto");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }

        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void eliminarProducto(String codigoProducto) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "DELETE FROM PRODUCTO WHERE CODIGO_PRODUCTO=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoProducto);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al eliminar la el producto");
            }

            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }

        } catch (SQLException ex) {
            showErrorMessage("Imposible eliminar el producto,\n"
                    + " asegurece que este producto no esta ligado a un proveedor,una orden o solicitud");
        }
    }

    public static void eliminarProductoBanco(Connection connection, String codigoProducto) {
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "DELETE FROM BANCO_DATOS WHERE CODIGO_PRODUCTO=?";
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoProducto);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al eliminar la el producto");
            }
            connection.commit();
            // Se destruyen los objetos


        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void eliminarProveedorBanco(Connection connection, String codigoProveedor) {
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "DELETE FROM BANCO_DATOS WHERE CODIGO_PROVEEDOR=?";
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoProveedor);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al eliminar el proveedor");
            }
            eliminarProveedorBanco(connection, codigoProveedor);
            connection.commit();


        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void eliminarProveedor(String codigoProveedor) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "DELETE FROM PROVEEDOR WHERE CODIGO_PROVEEDOR=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoProveedor);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al eliminar la el producto");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }

        } catch (SQLException ex) {
            showErrorMessage("Imposible eliminar el Proveedor,\n"
                    + " asegurece que este producto no esta ligado a un proveedor,una orden o solicitud");
        }
    }

    public static void eliminarDependencia(String codigoDependencia) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "DELETE FROM DEPENDENCIA WHERE CODIGO_DEPENDENCIA=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoDependencia);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al eliminar la dependencia");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }

        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static void eliminarBanco(String codigoBanco) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String CONSULTA = null;
        try {
            CONSULTA = "DELETE FROM BANCO_DATOS WHERE CODIGO_BANCO=?";
            connection = DatabaseConnection.getConexion();
            preparedStatement = connection.prepareStatement(CONSULTA);
            preparedStatement.setString(1, codigoBanco);

            /*
             * Se ejecuta la consulta
             */
            int filasInsertadas = preparedStatement.executeUpdate();
            if (filasInsertadas != 1) {
                throw new SQLException("Problemas al eliminar el banco.");
            }
            connection.commit();
            // Se destruyen los objetos
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }

        } catch (SQLException ex) {
            showErrorMessage(ex);
        }
    }

    public static List<Orden> generarOrdenDeCompra() {
        List<Solicitud> solicitudes = getSolicitud();
        List<Banco> banco = getDatosBanco();
        List<Orden> ordenes = null;
        for (Solicitud solicitud : solicitudes) {
            List<SolicitudDetalle> detallesSolicitud = solicitud.getDetalles();
            for (SolicitudDetalle detallesolicitud : detallesSolicitud) {
                ordenes = obtenerOrden(detallesolicitud, ordenes, banco);
            }
        }
        return ordenes;
    }

    public static List<Orden> ordenar(List<Orden> ordenes) {
        Orden aux;
        Orden tmp;
        for (int i = 0; i < ordenes.size(); i++) {
            for (int j = 0; j < ordenes.size() - 1; j++) {
                if (Integer.valueOf(ordenes.get(j).getCodigoOrden()) > Integer.valueOf(ordenes.get(j + 1).getCodigoOrden())) {

                    tmp = ordenes.get(j);
                    ordenes.add(j, ordenes.get(j + 1));
                    ordenes.add(j + 1, tmp);
                }
            }
        }
        return ordenes;
    }

    public static List<Orden> obtenerOrden(SolicitudDetalle detallesolicitud, List<Orden> ordenes, List<Banco> banco) {
        Producto producto = detallesolicitud.getProducto();
        Banco mejorBanco = mejorBanco(producto, banco);
        Orden orden = getOrden(ordenes, mejorBanco.getProveedor());
        String codigoOrden = null;
        if (ordenes == null) {
            codigoOrden = String.valueOf(getDatosBanco().size() - 1);
        } else {
            for (Orden ordentmp : ordenes) {
                if (ordentmp.getCodigoProveedor().equalsIgnoreCase(String.valueOf(mejorBanco.getProveedor().getCodigo()))) {
                    codigoOrden = ordentmp.getCodigoOrden();
                }
            }
            if (codigoOrden == null) {
                codigoOrden = String.valueOf(Integer.valueOf(ordenes.get(ordenes.size() - 1).getCodigoOrden()) + 1);
            }

        }

        String codigoProveedor = String.valueOf(mejorBanco.getProveedor().getCodigo());
        Calendar calendar = Calendar.getInstance();
        String date = String.valueOf(calendar.DATE).concat("/").concat(String.valueOf(calendar.MONTH).concat("/").concat(String.valueOf(calendar.YEAR)));

        if (orden == null) {
            List<OrdenDetalle> detallesOrden = new ArrayList<OrdenDetalle>();
            OrdenDetalle detalleorden = new OrdenDetalle("1", codigoOrden, producto, detallesolicitud.getCantidad());
            detallesOrden.add(detalleorden);
            orden = new Orden(codigoOrden, codigoProveedor, date, detallesOrden);
        } else {
            List<OrdenDetalle> detallesOrden = orden.getDetalles();
            String codigoDetalleOrden = String.valueOf(Integer.valueOf(detallesOrden.get(detallesOrden.size() - 1).getCodigoDetalle()) + 1);
            OrdenDetalle detalleorden = new OrdenDetalle(codigoDetalleOrden, codigoOrden, producto, detallesolicitud.getCantidad());
            detallesOrden.add(detalleorden);
            orden.setDetalles(detallesOrden);
        }
        if (ordenes == null) {
            ordenes = new ArrayList<Orden>();
        }
        List<Orden> ordenAux = new ArrayList<Orden>();
        for (Orden ordentmp : ordenes) {
            if (ordentmp.getCodigoProveedor() != orden.getCodigoProveedor()) {
                ordenAux.add(ordentmp);
            }
        }
        ordenAux.add(orden);
        return ordenAux;
    }

    public static Orden getOrden(List<Orden> ordenes, Proveedor proveedor) {
        if (ordenes != null) {
            for (Orden orden : ordenes) {
                if (orden.getCodigoProveedor().equalsIgnoreCase(String.valueOf(proveedor.getCodigo()))) {
                    return orden;
                }
            }
        }
        return null;
    }

    public static Banco mejorBanco(Producto producto, List<Banco> banco) {
        Banco bancoTmp = null;
        double precio = 999999999;
        for (Banco datosBanco : banco) {
            Producto productoBanco = datosBanco.getProducto();
            if (productoBanco.getCodigoProducto().equalsIgnoreCase(producto.getCodigoProducto())) {
                if (datosBanco.getPrecioUnidad() < precio) {
                    bancoTmp = datosBanco;
                }
            }
        }
        return bancoTmp;
    }
}
